# backend/api/admin.py
from flask import Blueprint, request, jsonify
# 移除JWT相关的导入
from backend.extensions import db
from backend.models import User, Project, UserProject, Sample
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

admin_bp = Blueprint('admin', __name__)

# 简化管理员访问检查
def check_admin_access():
    """简化检查用户是否为管理员"""
    # 这里可以实现简单的会话检查或其他方式
    # 暂时允许所有请求通过，后续可以添加更复杂的权限检查
    return True, None, 200

def get_current_user():
    """获取当前用户，这里简化处理，实际应从会话或token中获取"""
    # 暂时返回第一个用户作为示例
    return User.query.first()

@admin_bp.route('/users', methods=['GET'])
# 移除@jwt_required()
def get_all_users():
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        users = User.query.all()
        users_data = [user.to_dict() for user in users]
        logger.info(f"成功获取 {len(users_data)} 个用户")
        
        return jsonify(users_data), 200
    except Exception as e:
        logger.error(f"获取用户列表错误: {str(e)}", exc_info=True)
        return jsonify({'message': f'获取用户列表失败: {str(e)}'}), 500

@admin_bp.route('/users/<int:user_id>/status', methods=['PUT'])
def toggle_user_status(user_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 阻止用户修改自己的状态
        if current_user.user_id == user_id:
            return jsonify({'message': '不能修改当前用户的状态'}), 400
        
        user = User.query.get(user_id)
        if not user:
            return jsonify({'message': '用户不存在'}), 404
        
        # 切换用户状态 (active/inactive)
        if user.status == 'active':
            user.status = 'inactive'
        else:
            user.status = 'active'
            
        db.session.commit()
        
        return jsonify({'message': '用户状态更新成功', 'user': user.to_dict()}), 200
    except Exception as e:
        logger.error(f"更新用户状态错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '更新用户状态失败'}), 500

@admin_bp.route('/users/<int:user_id>', methods=['DELETE'])
# 移除@jwt_required()
def delete_user(user_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 阻止用户删除自己
        if current_user.user_id == user_id:
            return jsonify({'message': '不能删除当前用户'}), 400
        
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        user = User.query.get(user_id)
        if not user:
            return jsonify({'message': '用户不存在'}), 404
            
        if user.role == 'admin':
            return jsonify({'message': '不能删除管理员账户'}), 403
        
        db.session.delete(user)
        db.session.commit()
        
        return jsonify({'message': '用户删除成功'}), 200
    except Exception as e:
        logger.error(f"删除用户错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '删除用户失败'}), 500

# 其他路由保持不变，但移除JWT装饰器...
@admin_bp.route('/projects', methods=['GET'])
# 移除@jwt_required()
def get_projects():
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        projects = Project.query.all()
        projects_data = [{
            'id': p.id,
            'name': p.name,
            'description': p.description,
            'class_name': p.class_name,
            'status': p.status,
            'created_at': p.created_at.isoformat() if p.created_at else None,
            'updated_at': p.updated_at.isoformat() if p.updated_at else None
        } for p in projects]
        
        return jsonify(projects_data), 200
    except Exception as e:
        logger.error(f"获取项目列表错误: {str(e)}")
        return jsonify({'message': '获取项目列表失败'}), 500

@admin_bp.route('/projects', methods=['POST'])
# 移除@jwt_required()
def create_project():
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        data = request.get_json()
        
        if not data.get('name') or not data.get('class_name'):
            return jsonify({'message': '项目名称和分析流程名称都是必需的'}), 400
        
        # 检查项目名称是否已存在
        if Project.query.filter_by(name=data['name']).first():
            return jsonify({'message': '项目名称已存在'}), 409
        
        project = Project(
            name=data['name'],
            description=data.get('description', ''),
            class_name=data['class_name'],
            status=data.get('status', 'active')
        )
        
        db.session.add(project)
        db.session.commit()
        
        return jsonify({
            'message': '项目创建成功',
            'project': {
                'id': project.id,
                'name': project.name,
                'description': project.description,
                'class_name': project.class_name,
                'status': project.status
            }
        }), 201
    except Exception as e:
        logger.error(f"创建项目错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '创建项目失败'}), 500

@admin_bp.route('/projects/<int:project_id>', methods=['PUT'])
# 移除@jwt_required()
def update_project(project_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        project = Project.query.get(project_id)
        if not project:
            return jsonify({'message': '项目不存在'}), 404
        
        data = request.get_json()
        
        if 'name' in data:
            # 检查项目名称是否已存在（排除当前项目）
            existing_project = Project.query.filter(
                Project.name == data['name'],
                Project.id != project_id
            ).first()
            if existing_project:
                return jsonify({'message': '项目名称已存在'}), 409
            project.name = data['name']
        
        if 'description' in data:
            project.description = data['description']
        
        if 'class_name' in data:
            project.class_name = data['class_name']
        
        if 'status' in data:
            project.status = data['status']
        
        project.updated_at = db.func.current_timestamp()
        db.session.commit()
        
        return jsonify({
            'message': '项目更新成功',
            'project': {
                'id': project.id,
                'name': project.name,
                'description': project.description,
                'class_name': project.class_name,
                'status': project.status
            }
        }), 200
    except Exception as e:
        logger.error(f"更新项目错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '更新项目失败'}), 500

@admin_bp.route('/projects/<int:project_id>', methods=['DELETE'])
# 移除@jwt_required()
def delete_project(project_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        project = Project.query.get(project_id)
        if not project:
            return jsonify({'message': '项目不存在'}), 404
        
        db.session.delete(project)
        db.session.commit()
        
        return jsonify({'message': '项目删除成功'}), 200
    except Exception as e:
        logger.error(f"删除项目错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '删除项目失败'}), 500

@admin_bp.route('/user-projects', methods=['GET'])
# 移除@jwt_required()
def get_user_projects():
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        # 获取所有用户项目分配
        user_projects = UserProject.query.all()
        user_projects_data = []
        
        for up in user_projects:
            user_projects_data.append({
                'id': up.id,
                'user_id': up.user_id,
                'username': up.user.username,
                'project_id': up.project_id,
                'project_name': up.project.name,
                'status': up.status,
                'created_at': up.created_at.isoformat() if up.created_at else None,
                'updated_at': up.updated_at.isoformat() if up.updated_at else None
            })
        
        return jsonify(user_projects_data), 200
    except Exception as e:
        logger.error(f"获取用户项目分配错误: {str(e)}")
        return jsonify({'message': '获取用户项目分配失败'}), 500

@admin_bp.route('/user-projects', methods=['POST'])
# 移除@jwt_required()
def assign_project_to_user():
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        data = request.get_json()
        
        user_id = data.get('user_id')
        project_id = data.get('project_id')
        
        if not user_id or not project_id:
            return jsonify({'message': '用户ID和项目ID都是必需的'}), 400
        
        # 检查用户和项目是否存在
        user = User.query.get(user_id)
        if not user:
            return jsonify({'message': '用户不存在'}), 404
        
        project = Project.query.get(project_id)
        if not project:
            return jsonify({'message': '项目不存在'}), 404
        
        # 检查是否已经分配
        existing_assignment = UserProject.query.filter_by(
            user_id=user_id,
            project_id=project_id
        ).first()
        
        if existing_assignment:
            return jsonify({'message': '该项目已分配给该用户'}), 409
        
        # 创建分配记录
        user_project = UserProject(
            user_id=user_id,
            project_id=project_id,
            status=data.get('status', 'active')
        )
        
        db.session.add(user_project)
        db.session.commit()
        
        return jsonify({
            'message': '项目分配成功',
            'assignment': {
                'id': user_project.id,
                'user_id': user_project.user_id,
                'username': user_project.user.username,
                'project_id': user_project.project_id,
                'project_name': user_project.project.name,
                'status': user_project.status
            }
        }), 201
    except Exception as e:
        logger.error(f"分配项目错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '分配项目失败'}), 500

@admin_bp.route('/user-projects/<int:assignment_id>/samples', methods=['GET'])
# 移除@jwt_required()
def get_samples(assignment_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        # 检查分配是否存在
        user_project = UserProject.query.get(assignment_id)
        if not user_project:
            return jsonify({'message': '用户项目分配不存在'}), 404
        
        # 获取样本
        samples = Sample.query.filter_by(user_project_id=assignment_id).all()
        samples_data = [{
            'id': s.id,
            'name': s.name,
            'group_name': s.group_name,
            'metadata': s.sample_metadata,
            'created_at': s.created_at.isoformat() if s.created_at else None,
            'updated_at': s.updated_at.isoformat() if s.updated_at else None
        } for s in samples]
        
        return jsonify(samples_data), 200
    except Exception as e:
        logger.error(f"获取样本错误: {str(e)}")
        return jsonify({'message': '获取样本失败'}), 500

@admin_bp.route('/user-projects/<int:assignment_id>/samples', methods=['POST'])
# 移除@jwt_required()
def add_sample(assignment_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        # 检查分配是否存在
        user_project = UserProject.query.get(assignment_id)
        if not user_project:
            return jsonify({'message': '用户项目分配不存在'}), 404
        
        data = request.get_json()
        
        if not data.get('name'):
            return jsonify({'message': '样本名称是必需的'}), 400
        
        sample = Sample(
            user_project_id=assignment_id,
            name=data['name'],
            group_name=data.get('group_name', ''),
            sample_metadata=data.get('metadata', {})
        )
        
        db.session.add(sample)
        db.session.commit()
        
        return jsonify({
            'message': '样本添加成功',
            'sample': {
                'id': sample.id,
                'name': sample.name,
                'group_name': sample.group_name,
                'metadata': sample.sample_metadata
            }
        }), 201
    except Exception as e:
        logger.error(f"添加样本错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '添加样本失败'}), 500

@admin_bp.route('/samples/<int:sample_id>', methods=['PUT'])
# 移除@jwt_required()
def update_sample(sample_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        sample = Sample.query.get(sample_id)
        if not sample:
            return jsonify({'message': '样本不存在'}), 404
        
        data = request.get_json()
        
        if 'name' in data:
            sample.name = data['name']
        
        if 'group_name' in data:
            sample.group_name = data['group_name']
        
        if 'metadata' in data:
            sample.sample_metadata = data['metadata']
        
        sample.updated_at = db.func.current_timestamp()
        db.session.commit()
        
        return jsonify({
            'message': '样本更新成功',
            'sample': {
                'id': sample.id,
                'name': sample.name,
                'group_name': sample.group_name,
                'metadata': sample.sample_metadata
            }
        }), 200
    except Exception as e:
        logger.error(f"更新样本错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '更新样本失败'}), 500

@admin_bp.route('/samples/<int:sample_id>', methods=['DELETE'])
# 移除@jwt_required()
def delete_sample(sample_id):
    try:
        # 检查当前用户是否为管理员
        current_user = get_current_user()
        if not current_user or current_user.role != 'admin':
            return jsonify({'message': '权限不足，只有管理员可以访问'}), 403
            
        # 移除JWT检查
        # is_admin, result, status_code = check_admin_access()
        # if not is_admin:
        #     return jsonify(result), status_code
        
        sample = Sample.query.get(sample_id)
        if not sample:
            return jsonify({'message': '样本不存在'}), 404
        
        db.session.delete(sample)
        db.session.commit()
        
        return jsonify({'message': '样本删除成功'}), 200
    except Exception as e:
        logger.error(f"删除样本错误: {str(e)}")
        db.session.rollback()
        return jsonify({'message': '删除样本失败'}), 500